ALMaSS  1.0
The Animal, Landscape and Man Simulation System
Hunters ODdox Documentation

Version 1.01

Created by:
Chris J. Topping
Department of Bioscience,
Aarhus University
Grenaavej 14
DK-8410 Roende
Denmark

31st October 2013




The ALMaSS Hunter Model description


1. PURPOSE

The hunter model is not a model in its own right, but forms a sub-model which can be used in a simulation together with game species animal models. Current functionality is restricted to the Goose Management Model, but it is designed to be extensible to other hunter types. The hunters are implemented by creating an instance of the Hunter_Population_Manager class. This class provides the interface to the animal (prey) population. The purpose of the hunter model is therefore to provide simulation of hunters and the mortality they inflict on a prey population.

2. STATE VARIABLES AND SCALES

The basic entity of the simulation is a single hunter. The hunters are designated a type e.g. GooseHunter Currently only GooseHunter is implemented. Specialist hunter types are descended from the class Hunter which has all the basic information and behaviour common to all hunters.

Hunter class attributes:
int Hunter::m_myname A reference number unique to this hunter.
TTypeOfHunterState Hunter::CurrentHState The current hunter behavioural state.
Hunter_Population_Manager * m_OurPopulationManager Pointer to the population manager (program construct). int Hunter::m_clock Records the time spent hunting per day (mins).
int Hunter::m_bag The numbers of game items shot todate this year(individuals).
int Hunter::m_huntingdays The numbers of days used for hunting this year (days).
int Hunter::m_baglimit Annual self-imposed limit on number shot (individuals).
int Hunter::m_huntlimit Annual self-imposed limit on number of days spent hunting (days).
double Hunter::m_efficiency Probability of 'hitting' a game item when shooting (no units).
int Hunter::m_OurFarmer The famer that owns the fields the hunter uses (program construct, pointer to Farm).
int Hunter::m_weekend Code for weekly hunting activity. Weekend only, mostly weekend, or anytime hunting (no units).

GooseHunter Attributes:
bool GooseHunter::m_dugin Flag to indicate whether we have currently in a hunting location (true/false).
Goose_Population_Manager* GooseHunter::m_preyPopulationManger Pointer to our game population, the geese, a program construct (no units).
polylist* GooseHunter::m_huntlocations Our list of possible hunting locations as polygon reference numbers as supplied by Landscape::SupplyPolyRef (program construct).
int GooseHunter::m_huntloc_index The index to our current hunting location (program construct).

Hunter_Population_Manager Attributes:
unsigned Hunter_Population_Manager::m_NoHunterTypes The number of current operational hunter types (program construct).
unsigned Hunter_Population_Manager::m_daytime The time of day, in minutes.
ofstream* Hunter_Population_Manager::m_HuntingBagRecord An output file storing details of the birds shot (program construct).

3. PROCESS OVERVIEW AND SCHEDULING


The hunters daily routine is described by the flow diagram below. The hunters start the day in the red diamond and end it in the red rectangle.


Hunters have three basic behaviours:

Hunter::st_ShouldGoHunting Decide whether to go out hunting on a specific day.
This behaviouris called at the beginning of a day of hunting (this will not necessarily be from midnight, but from the first point at which hunting can take place, e.g. dawn.
The behaviour is carried out as follows: First we check that we have not shot our limit this year or done our allocated number of days, if so do nothing.
Otherwise we want to find out if we should hunt today. This depends on the season (implemented in a hunter type specific version of Hunter e.g. GooseHunter::InSeason for our game species, and whether we want to hunt today, which in turn depends on whether it is a weekend or not, and then how eager we are. There are three types of hunter. These are weekend hunters, weekend and possibly weekday hunters, and any day hunters. Weekday hunting is controlled by an input variable #cfg_hunterweekdayhuntprob, and for anyday hunters the probability of hunting is double the #cfg_hunterweekdayhuntprob value.

Hunter::st_Resting Finished the hunt and waiting for the next opportunity to go hunting. This is a 'do nothing' behaviour, waiting until called to hunt again by the Hunter_Population_Manager.

Hunter::st_OutHunting Hunt. This is defined for each specialist hunter type.

Goose Hunters are represented by the Goose_Hunter class behaviours. This has specialist behaviours only exhibited by the goose hunters:

GooseHunter::st_OutHunting Simulates a 10 minute hunting timestep. Must determine the time spent hunting and the time of day. If it is the first time this is called today then find a hunting location. If a hunting location is found then wait for geese, and determine the probability of shooting them if any turn up. Once the hunting time is used up, then come home.

GooseHunter::FindHuntingLocation is used to find a hunting location, which is picked from the list of possible hunting locations at random. Once this is found look and see if there is anything to shoot by asking the Goose_Population_Manager::BirdsToShootAtPoly This returns the number of birds there at that 10 minute period. This is done assessing a range from our location, which we will be centrally placed in a field so the real location is not precise beyond this resolution.Birds will also be located at the field level, so a simplifying assumption here is that a bird in the same field is 'fair game', outside the field it is not.
Once we determine that there is something to shoot at, then we need to determine whether, we try and shoot, if so whether we hit the bird. If we shoot this must be registered in the system as an event, and any goose near enough to be affected will need to be told of this.
To Determine if we try to shoot and the chance of hitting, right now we assume we always shoot and the chance of hitting something is our skill - held in m_efficiency. The hunter has two shots. If we hit a bird then this is detected by the Goose_Population_Manager and GooseHunter::OnShotABird is invoked.The Goose_Population_Manager also creates a 'BANG' which is heard by geese nearby, regardless of whether a goose is shot.

GooseHunter::OnShotABird simply records the hunting success if storing of hunting data is selected by cfg_Hunters_RecordBag

GooseHunter::InSeason Determines whether it is hunting season on the geese. This is controlled by input variables cfg_gooseopenseasonstart and cfg_gooseopenseasonend

The hunter's population manager Hunter_Population_Manager is responsible for managing the list of hunters and controlling the timing of their behaviours. Most of the functionality is inherited from Population_Manager, but specific functions for hungers are controlled using the following methods:

Hunter_Population_Manager::Init Creates the initial hunter population with each individual with their own hunting pattern in terms of timing, location, and intensity/efficiency. Information on hunters is specified in the "Hunter_Initiation.txt" file (See Initialisation below).
One of the challenges is to ensure that we have a matching prey population for each hunter. This is achieved by two structures, the first being a variable in each Population_Manager that states its type (Population_Manager::m_population_type) and its associated enum populationmanager::TTypesOfPopulation . The second is a globally visible structure holding a list of any active population managers g_PopulationManagerList .
This method also initializes any output options.

Hunter_Population_Manager::CreateObjects is responsible for creating the actual hunter objects and assigning them to the lists. There are checks to ensure that only valid hunter types are created.

Hunter_Population_Manager::DoFirst is the main location where hunter specific behaviours controlled or monitored. Initially if it is the start of a new day then all daily hunter clocks are reset to the start of a new day using Hunter::ResetClock and Hunter::OnMorning If it is the start of a new year then hunter bag records are also reset using Hunter::ResetYear - NB this assumes that a hunting season finishes by December 31st. In all cases the time of day is advanced by 10 minutes and recorded in Hunter_Population_Manager::m_daytime.

Hunter_Population_Manager::RecordHuntingSuccess This method stores information about the birds that have been shot. It is essential that the hunting bag record file is open when this is called - there is no checking. This is controlled by a configuration variable cfg_Hunters_RecordBag


4. DESIGN CONCEPTS


4.A EMERGENCE

The gamebag is an emergent property of the interacton between the hunting behaviour and the prey foraging and flight/threat responses.

4.B. ADAPTATION

Hunters do not use adaptive behaviour.

4.C FITNESS

There is not fitness characteristic for hunters. There is no consequence of failing to shoot geese.

4.D PREDICTION

Prediction is used insofar as the numbers of birds in the previous day are used to predict the likelihood of going to a field when finding a hunting location. However, the likelihood of exercising the checking for geese option is an individual characteristic of each hunter and set by the hunter input file Hunter_Initiation.txt.

4.E SENSING

Hunters can sense the presence of geese within the field that they are hunting on.

4.F INTERACTION

Hunters interact directly with geese that they shoot, with geese that hear the shots, and indirectly with each other if they hunt in the same areas.

4.G STOCHASTICITY

Hunting success is probabilistic.

4.H COLLECTIVES

Hunters that find themselves hunting on the same landscape polygon (normally a field) are organised into a single team. The first hunter to decide to hunt there is designated the team leader and controls hunting decsions regarding when to shoot. Other team members will follow his lead in shooting and stop hunting when he does.

4.I OBSERVATION

Hunting bags can be recorded by Hunter_Population_Manager::RecordHuntingSuccess and will record the number of birds shot, their type and location.

5. INITIALISATION

Hunters require an initialisation file describing each hunter. The file is always called Hunter_Initiation.txt The format of the file is tab-delimited and consists of an initial entry of an integer describing the number of hunter entries in the files followed by that number of rows in the following format:
Hunter type (0 = Goose Hunter); x location; y location; reference number identifying the farm the hunter hunts (only one allowed), weekend hunter (0,1,2) 0 = weekend only, 1 = primarily weekend but occasionally weekdays, 2 = all week; hunting bag limit; hunting day limit, efficiency (hit probability) e.g. four goose hunters:
4
1 0 2500 2500 0 0 10000 2000 0.75
2 0 2500 7500 2 1 10000 2000 0.85
3 0 7500 2500 3 2 10000 2000 0.1
4 0 7500 7500 1 0 10000 2000 0.75


6. INPUTS

  • GOOSE_OPENSEASON_START cfg_gooseopenseasonstart The first day of the goose open season (zero based day in year number). Default day 242
  • GOOSE_OPENSEASON_END cfg_gooseopenseasonend. The last day of the goose open season (zero based day in year number). Default day 364
  • HUNTERWEEKDAYHUNTPROB #cfg_hunterweekdayhuntprob The probability of going hunting on a weekday. Deafult value: 0.05
  • GOOSE_HUNTER_HUNT_LENGTH cfg_huntlength How long the hunters spend hunting each day (mins). The default is 3 hours.
  • HUNTERS_RECORDBAG cfg_Hunters_RecordBag Determines whether a record of the hunting bag is produced (binary) Default value: false


7. INTERCONNECTIONS

The hunters rely on information from the Landscape and from their prey population manager e.g. Goose_Population_Manager. As with all populations in ALMaSS the hunter population manager uses the basic functinality of the Population_Mangager class.

8. REFERENCES